home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / SNNSV32.ZIP / SNNSv3.2 / kernel / sources / kr_funcs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  12.2 KB  |  471 lines
  1. /*****************************************************************************
  2.   FILE           : kr_funcs.c
  3.   SHORTNAME      : 
  4.   SNNS VERSION   : 3.2
  5.  
  6.   PURPOSE        : SNNS-Kernel: Management routines for user functions 
  7.   NOTES          :
  8.  
  9.   AUTHOR         : Niels Mache
  10.   DATE           : 12.02.90
  11.  
  12.   CHANGED BY     : Sven Doering
  13.   IDENTIFICATION : @(#)kr_funcs.c    1.8 3/15/94
  14.   SCCS VERSION   : 1.8
  15.   LAST CHANGE    : 3/15/94
  16.  
  17.              Copyright (c) 1990-1994  SNNS Group, IPVR, Univ. Stuttgart, FRG
  18.  
  19. ******************************************************************************/
  20. #include <string.h>
  21.  
  22. #include "kr_typ.h"         /*  Kernel types and constants  */
  23. #include "kr_const.h"       /*  Kernel constants  */
  24. #include "kr_def.h"        /*    Default values    */
  25. #include "kr_funcs.ph"       /*  Function prototypes  */
  26. #include "kernel.h"
  27. #include "func_tbl.h"
  28.  
  29.  
  30. /*#################################################
  31.  
  32. GROUP: MasPar functions
  33.  
  34. #################################################*/
  35.  
  36. #ifdef MASPAR_KERNEL
  37. #ifndef MASPAR_KERNEL_EMULATION
  38.  
  39. extern  krmp_getMasParFuncInfo();
  40.  
  41. #endif
  42. #endif
  43.  
  44.  
  45. /*#################################################
  46.  
  47. GROUP: Functions
  48.  
  49. #################################################*/
  50. /*****************************************************************************
  51.   FUNCTION : krf_getInternalFuncInfo 
  52.  
  53.   PURPOSE  : 
  54.   NOTES    :
  55.  
  56.   RETURNS  :
  57.   UPDATE   : 
  58. ******************************************************************************/
  59.  
  60. static krui_err  krf_getInternalFuncInfo(int mode, struct FuncInfoDescriptor *func_descr)
  61. {
  62.   struct FuncTable  *ftbl_ptr;
  63.   unsigned short  func_type;
  64.  
  65.  
  66.   KernelErrorCode = KRERR_NO_ERROR;
  67.  
  68.   switch (mode)  {
  69.     case  GET_NO_OF_FUNCS:
  70.       func_descr->number = NoOfKernelFuncs;
  71.       break;
  72.  
  73.     case  GET_FUNC_INFO:  /*  return all info about given function  */
  74.       if ((func_descr->number < 0) || (func_descr->number >= NoOfKernelFuncs))  {
  75.         KernelErrorCode = KRERR_PARAMETERS;
  76.         return( KernelErrorCode );
  77.       }
  78.  
  79.       ftbl_ptr = kernel_func_table + func_descr->number;
  80.  
  81.       strcpy( func_descr->func_name, ftbl_ptr->func_name );
  82.       func_descr->func_type = ftbl_ptr->func_type & ~DEFAULT_FUNC;
  83.       func_descr->no_of_input_parameters = ftbl_ptr->no_of_input_parameters;
  84.       func_descr->no_of_output_parameters = ftbl_ptr->no_of_output_parameters;
  85.       func_descr->function = ftbl_ptr->function;
  86.  
  87.       break;
  88.  
  89.     case  SEARCH_FUNC:  /*  search for the given function and return the
  90.                             info about the function  */
  91.  
  92.       for (ftbl_ptr = kernel_func_table;
  93.            ftbl_ptr < kernel_func_table + NoOfKernelFuncs;
  94.            ftbl_ptr++)  {
  95.         func_type = func_descr->func_type;
  96.         if ((func_type == (ftbl_ptr->func_type & ~DEFAULT_FUNC)) &&
  97.             (strcmp( func_descr->func_name, ftbl_ptr->func_name ) == 0))  {
  98.           func_descr->no_of_input_parameters = ftbl_ptr->no_of_input_parameters;
  99.           func_descr->no_of_output_parameters = ftbl_ptr->no_of_output_parameters;
  100.           func_descr->function = ftbl_ptr->function;
  101.  
  102.           return( KRERR_NO_ERROR );
  103.         }
  104.       }
  105.  
  106.       func_descr->function = NULL;
  107.  
  108.       switch (func_descr->func_type)  {
  109.         case  OUT_FUNC:
  110.           KernelErrorCode = KRERR_OUTFUNC;
  111.           break;
  112.         case  ACT_FUNC:
  113.           KernelErrorCode = KRERR_ACTFUNC;
  114.           break;
  115.         case  SITE_FUNC:
  116.           KernelErrorCode = KRERR_SITEFUNC;
  117.           break;
  118.         case  LEARN_FUNC:
  119.           KernelErrorCode = KRERR_LEARNING_FUNC;
  120.           break;
  121.         case  UPDATE_FUNC:
  122.           KernelErrorCode = KRERR_UPDATE_FUNC;
  123.           break;
  124.         case  INIT_FUNC:
  125.           KernelErrorCode = KRERR_INIT_FUNC;
  126.           break;
  127.         case  ACT_DERIV_FUNC:
  128.           KernelErrorCode = KRERR_DERIV_FUNC;
  129.           break;
  130.  
  131.         default:
  132.           KernelErrorCode = KRERR_PARAMETERS;
  133.       }
  134.  
  135.       break;
  136.  
  137.     case  GET_FUNC_NAME:   /*  search for the given function pointer and
  138.                                returns the name of the function  */
  139.  
  140.       for (ftbl_ptr = kernel_func_table;
  141.            ftbl_ptr < kernel_func_table + NoOfKernelFuncs;
  142.            ftbl_ptr++)
  143.         if (func_descr->function == ftbl_ptr->function)  {
  144.           strcpy( func_descr->func_name, ftbl_ptr->func_name );
  145.           func_descr->func_type = ftbl_ptr->func_type & ~DEFAULT_FUNC;
  146.           func_descr->no_of_input_parameters = ftbl_ptr->no_of_input_parameters;
  147.           func_descr->no_of_output_parameters = ftbl_ptr->no_of_output_parameters;
  148.  
  149.           return( KRERR_NO_ERROR );
  150.         }
  151.  
  152.       func_descr->func_type = 0;
  153.       break;
  154.  
  155.     case  GET_DEFAULT_FUNC:   /*  search for the given function type and
  156.                                   returns the default function of this type  */
  157.  
  158.       func_type = func_descr->func_type | DEFAULT_FUNC;
  159.       for (ftbl_ptr = kernel_func_table;
  160.            ftbl_ptr < kernel_func_table + NoOfKernelFuncs;
  161.            ftbl_ptr++)  {
  162.         if (func_type == ftbl_ptr->func_type)  {
  163.           func_descr->no_of_input_parameters = ftbl_ptr->no_of_input_parameters;
  164.           func_descr->no_of_output_parameters = ftbl_ptr->no_of_output_parameters;
  165.           func_descr->function = ftbl_ptr->function;
  166.           strcpy( func_descr->func_name, ftbl_ptr->func_name );
  167.           func_descr->number = ftbl_ptr - kernel_func_table;
  168.           return( KRERR_NO_ERROR );
  169.         }
  170.       }
  171.  
  172.       func_descr->number = 0;
  173.       KernelErrorCode = KRERR_MISSING_DEFAULT_FUNC;
  174.       break;
  175.  
  176.     default:
  177.       KernelErrorCode = KRERR_PARAMETERS;
  178.   }
  179.  
  180.   return( KernelErrorCode );
  181. }
  182.  
  183.  
  184. /*****************************************************************************
  185.   FUNCTION : krf_getFuncInfo
  186.  
  187.   PURPOSE  : 
  188.   NOTES    :
  189.  
  190.   RETURNS  :
  191.   UPDATE   : 
  192. ******************************************************************************/
  193.  
  194. krui_err  krf_getFuncInfo(int mode, struct FuncInfoDescriptor *func_descr)
  195. {
  196.   switch (specialNetworkType)  {
  197.     case NET_TYPE_GENERAL:
  198.       (void) krf_getInternalFuncInfo( mode, func_descr );
  199.       break;
  200.  
  201. #ifdef MASPAR_KERNEL
  202.  
  203.     case NET_TYPE_FF1:
  204.  
  205. #ifndef MASPAR_KERNEL_EMULATION
  206.       
  207.   
  208.       KernelErrorCode = callRequest( krmp_getMasParFuncInfo,
  209.                                      sizeof (int) +
  210.                                      sizeof (struct FuncInfoDescriptor *),
  211.                                      mode, func_descr );
  212. #else
  213.       (void) krf_getInternalFuncInfo( mode, func_descr );
  214. #endif
  215.  
  216.       break;
  217. #endif
  218.  
  219.     default:
  220.       KernelErrorCode = KRERR_PARAMETERS;
  221.   }
  222.  
  223.   return( KernelErrorCode );
  224. }
  225.  
  226. /*****************************************************************************
  227.   FUNCTION : krf_getNoOfFuncs
  228.  
  229.   PURPOSE  : Returns the number of functions in the function table
  230.   NOTES    :
  231.  
  232.   RETURNS  : Returns the number of functions in the function table
  233.   UPDATE   : 
  234. ******************************************************************************/
  235. int  krf_getNoOfFuncs(void)
  236. {
  237.   struct FuncInfoDescriptor  functionDescr;
  238.  
  239.  
  240.   KernelErrorCode = krf_getFuncInfo( GET_NO_OF_FUNCS, &functionDescr );
  241.   return( functionDescr.number );
  242. }
  243.  
  244. /*****************************************************************************
  245.   FUNCTION : krf_funcSearch
  246.  
  247.   PURPOSE  : seaches for the given function (name and type) and returns a pointer to
  248.              this function. krf_funcSearch(...)
  249.   NOTES    :
  250.  
  251.   RETURNS  : TRUE if the given function was found, FALSE otherwise.
  252.   UPDATE   : 
  253. ******************************************************************************/
  254. bool  krf_funcSearch(char *func_name, int func_type, FunctionPtr *func_ptr)
  255. {
  256.   struct FuncInfoDescriptor  functionDescr;
  257.  
  258.   functionDescr.func_type = func_type;
  259.   strcpy( functionDescr.func_name, func_name );
  260.  
  261.   KernelErrorCode = krf_getFuncInfo( SEARCH_FUNC, &functionDescr );
  262.  
  263.   if (KernelErrorCode != KRERR_NO_ERROR)  return( FALSE );
  264.   *func_ptr = functionDescr.function;
  265.   return( TRUE );
  266. }
  267. /*****************************************************************************
  268.   FUNCTION : krf_getFuncName
  269.  
  270.   PURPOSE  : 
  271.   NOTES    :
  272.  
  273.   RETURNS  : Returns the name of the given function
  274.   UPDATE   : 
  275. ******************************************************************************/
  276. char  *krf_getFuncName(FunctionPtr func_ptr)
  277. {
  278.   static struct FuncInfoDescriptor  functionDescr;
  279.  
  280.   functionDescr.function = func_ptr;
  281.  
  282.   KernelErrorCode = krf_getFuncInfo( GET_FUNC_NAME, &functionDescr );
  283.  
  284.   if (functionDescr.func_type == 0)  return( NULL );
  285.  
  286.   return( functionDescr.func_name );
  287. }
  288.  
  289.  
  290. /*#################################################
  291.  
  292. GROUP: Functions for managing current and
  293.        default network functions
  294.  
  295. #################################################*/
  296. /*****************************************************************************
  297.   FUNCTION : krf_getCurrentNetworkFunc
  298.  
  299.   PURPOSE  : 
  300.   NOTES    :
  301.  
  302.   RETURNS  : returns the name of the current network function
  303.   UPDATE   : 
  304. ******************************************************************************/
  305. char  *krf_getCurrentNetworkFunc(int type)
  306. {
  307.   int  sel;
  308.   static struct FuncInfoDescriptor  func_descr;
  309.  
  310.  
  311.   KernelErrorCode = KRERR_NO_ERROR;
  312.  
  313.   if (specialNetworkType == NET_TYPE_GENERAL)  sel = 0;
  314.   else  sel = NO_OF_FUNC_TYPES;
  315.  
  316.   switch (type)  {
  317.     case  UPDATE_FUNC:
  318.       break;
  319.     case  LEARN_FUNC:
  320.       sel += 1;
  321.       break;
  322.     case  INIT_FUNC:
  323.       sel += 2;
  324.       break;
  325.     case  OUT_FUNC:
  326.       sel += 3;
  327.       break;
  328.     case  ACT_FUNC:
  329.       sel += 4;
  330.       break;
  331.     case  SITE_FUNC:
  332.       sel += 5;
  333.       break;
  334.     case  UPDATE_FUNC | BENCH_FUNC:
  335.       sel += 6;
  336.       break;
  337.     case  LEARN_FUNC | BENCH_FUNC:
  338.       sel += 7;
  339.       break;
  340.  
  341.    default:
  342.      KernelErrorCode = KRERR_PARAMETERS;
  343.      return( NULL );
  344.   }
  345.  
  346.   if (netFuncInit[sel])  return( &CurrNetworkFunc[sel][0] );
  347.  
  348.   func_descr.func_type = type;
  349.   if (krf_getFuncInfo( GET_DEFAULT_FUNC, &func_descr ) == KRERR_NO_ERROR)
  350.     return( func_descr.func_name );
  351.  
  352.   return( NULL );
  353. }
  354.  
  355. /*****************************************************************************
  356.   FUNCTION : krf_storeCurrentNetworkFunc
  357.  
  358.   PURPOSE  : 
  359.   NOTES    :
  360.  
  361.   RETURNS  : 
  362.   UPDATE   : 
  363. ******************************************************************************/
  364.  
  365. static void  krf_storeCurrentNetworkFunc(char *function_name, int type)
  366. {
  367.   int  sel;
  368.  
  369.   if (specialNetworkType == NET_TYPE_GENERAL)  sel = 0;
  370.   else  sel = 3;
  371.  
  372.  
  373.   switch (type)  {
  374.     case  UPDATE_FUNC:
  375.       break;
  376.     case  LEARN_FUNC:
  377.       sel += 1;
  378.       break;
  379.     case  INIT_FUNC:
  380.       sel += 2;
  381.       break;
  382.     case  OUT_FUNC:
  383.       sel += 3;
  384.       break;
  385.     case  ACT_FUNC:
  386.       sel += 4;
  387.       break;
  388.     case  SITE_FUNC:
  389.       sel += 5;
  390.       break;
  391.     case  UPDATE_FUNC | BENCH_FUNC:
  392.       sel += 6;
  393.       break;
  394.     case  LEARN_FUNC | BENCH_FUNC:
  395.       sel += 7;
  396.       break;
  397.  
  398.    default:
  399.      KernelErrorCode = KRERR_PARAMETERS;
  400.      return;
  401.     }
  402.  
  403.   netFuncInit[sel] = TRUE;
  404.   strcpy( &CurrNetworkFunc[sel][0], function_name );
  405.   return;
  406. }
  407.  
  408.  
  409.  
  410. /*****************************************************************************
  411.   FUNCTION : krf_setCurrentNetworkFunc
  412.  
  413.   PURPOSE  : sets the current network function.
  414.   NOTES    :
  415.  
  416.   RETURNS  : 
  417.   UPDATE   : 
  418. ******************************************************************************/
  419. krui_err  krf_setCurrentNetworkFunc(char *function_name, int type)
  420. {
  421.   FunctionPtr func_ptr;
  422.   bool    func_has_changed;
  423.   char  *current_func;
  424.  
  425.   KernelErrorCode = KRERR_NO_ERROR;
  426.  
  427.   if (!krf_funcSearch( function_name, type, &func_ptr ))
  428.     return( KernelErrorCode );
  429.   if ((current_func = krf_getCurrentNetworkFunc( type )) == NULL)
  430.     return( KernelErrorCode );
  431.  
  432.   func_has_changed = strcmp( function_name, current_func ) != 0;
  433.  
  434.   switch (type)  {
  435.     case  UPDATE_FUNC:
  436.       if (func_has_changed)
  437.     {  /*  update function has changed, initialize the network  */
  438.         NetInitialize = TRUE;
  439.         krf_storeCurrentNetworkFunc( function_name, type );
  440.       }
  441.  
  442.       return( KernelErrorCode );
  443.  
  444.     case  LEARN_FUNC:
  445.       if (func_has_changed)
  446.     {  /*  Learning function has changed  */
  447.     LearnFuncHasChanged = TRUE;
  448.         krf_storeCurrentNetworkFunc( function_name, type );
  449.       }
  450.  
  451.       return( KernelErrorCode );
  452.  
  453.     case  INIT_FUNC:
  454.     case  OUT_FUNC:
  455.     case  ACT_FUNC:
  456.     case  SITE_FUNC:
  457.       krf_storeCurrentNetworkFunc( function_name, type );
  458.       break;
  459.  
  460.    default:
  461.       KernelErrorCode = KRERR_PARAMETERS;
  462.       return( KernelErrorCode );
  463.   }
  464.  
  465.   return( KernelErrorCode );
  466. }
  467.  
  468.  
  469.  
  470.  
  471.